package com.ruoyi.web.controller.api;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.YdMeterData;
import com.ruoyi.system.service.IYdMeterDataService;

/**
 * 易达电表数据接收API控制器
 * 
 * @author ruoyi
 * @date 2024-01-15
 */
@RestController
@RequestMapping("/api/ydMeterData")
public class YdMeterDataApiController extends BaseController
{
    private static final Logger log = LoggerFactory.getLogger(YdMeterDataApiController.class);
    
    @Autowired
    private IYdMeterDataService ydMeterDataService;

    /**
     * 接收电表数据
     * 
     * @param ydMeterData 电表数据
     * @return 结果
     */
    @Log(title = "易达电表数据", businessType = BusinessType.INSERT)
    @PostMapping("/receive")
    public AjaxResult receive(@RequestBody YdMeterData ydMeterData)
    {
        try {
            // 必要参数验证
            if (StringUtils.isEmpty(ydMeterData.getDeviceId()))
            {
                return AjaxResult.error("设备ID不能为空");
            }
            
            if (ydMeterData.getCollectTime() == null)
            {
                return AjaxResult.error("采集时间不能为空");
            }
            
           if (ydMeterData.getActivePower() == null)
            {
                return AjaxResult.error("有功功率不能为空");
            }
            
            // 设置默认值
            if (ydMeterData.getStatus() == null)
            {
                ydMeterData.setStatus(1); // 默认状态为正常
            }
            
            ydMeterData.setCreateBy("api");
            ydMeterData.setCreateTime(new Date());
            
            // 保存数据
            int result = ydMeterDataService.insertYdMeterData(ydMeterData);
            
            if (result > 0)
            {
                log.info("接收电表数据成功，设备ID：{}，采集时间：{}，炉号：{}", 
                    ydMeterData.getDeviceId(), ydMeterData.getCollectTime(), ydMeterData.getFurnaceNo());
                return AjaxResult.success("数据接收成功");
            }
            else
            {
                log.error("接收电表数据失败，设备ID：{}，采集时间：{}", ydMeterData.getDeviceId(), ydMeterData.getCollectTime());
                return AjaxResult.error("数据保存失败");
            }
        }
        catch (Exception e)
        {
            log.error("接收电表数据异常", e);
            return AjaxResult.error("系统异常：" + e.getMessage());
        }
    }

    /**
     * 查询设备最新数据
     * 
     * @param deviceId 设备ID
     * @return 结果
     */
    @GetMapping("/latest")
    public AjaxResult getLatestData(@RequestParam String deviceId)
    {
        try {
            if (StringUtils.isEmpty(deviceId))
            {
                return AjaxResult.error("设备ID不能为空");
            }
            
            YdMeterData data = ydMeterDataService.getLastDataByDeviceId(deviceId);
            return AjaxResult.success(data);
        }
        catch (Exception e)
        {
            log.error("查询设备最新数据异常，设备ID：{}", deviceId, e);
            return AjaxResult.error("查询失败：" + e.getMessage());
        }
    }

    
    /**
     * 按时间范围查询数据
     * 
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return 结果
     */
    @GetMapping("/queryByTime")
    public AjaxResult queryByTime(@RequestParam String startDate,
                                 @RequestParam String endDate)
    {
        try {
            if (StringUtils.isEmpty(startDate) || StringUtils.isEmpty(endDate))
            {
                return AjaxResult.error("开始日期和结束日期不能为空");
            }
            
            List<YdMeterData> dataList = ydMeterDataService.selectDataByTimeRange(startDate, endDate);
            return AjaxResult.success(dataList);
        }
        catch (Exception e)
        {
            log.error("按时间范围查询数据异常，开始日期：{}，结束日期：{}", startDate, endDate, e);
            return AjaxResult.error("查询失败：" + e.getMessage());
        }
    }

    /**
     * 统计数据
     * 
     * @param type 统计类型：day-按日统计，furnace-按炉号统计
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return 结果
     */
    @GetMapping("/statistics")
    public AjaxResult statistics(@RequestParam String type,
                                @RequestParam String startDate,
                                @RequestParam String endDate)
    {
        try {
            if (StringUtils.isEmpty(type) || StringUtils.isEmpty(startDate) || StringUtils.isEmpty(endDate))
            {
                return AjaxResult.error("参数不能为空");
            }
            
            List<Map<String, Object>> result;
            
            if ("day".equals(type))
            {
                result = ydMeterDataService.statisticsByDay(startDate, endDate);
            }
            else if ("furnace".equals(type))
            {
                result = ydMeterDataService.statisticsByFurnace(startDate, endDate);
            }
            else
            {
                return AjaxResult.error("不支持的统计类型");
            }
            
            return AjaxResult.success(result);
        }
        catch (Exception e)
        {
            log.error("统计数据异常，类型：{}，开始日期：{}，结束日期：{}", type, startDate, endDate, e);
            return AjaxResult.error("统计失败：" + e.getMessage());
        }
    }
    
    /**
     * 分页查询电表数据列表
     * 
     * @param furnaceNo 炉号（可选）
     * @param startDate 开始日期（可选，支持格式：yyyy-MM-dd 或 yyyy-MM-dd HH:mm:ss）
     * @param endDate 结束日期（可选，支持格式：yyyy-MM-dd 或 yyyy-MM-dd HH:mm:ss）
     * @param pageNum 当前页码
     * @param pageSize 每页记录数
     * @return 结果
     */
    @GetMapping("/queryList")
    public TableDataInfo queryList(@RequestParam(required = false) Integer furnaceNo,
                                 @RequestParam(required = false) String startDate,
                                 @RequestParam(required = false) String endDate,
                                 @RequestParam(defaultValue = "1") Integer pageNum,
                                 @RequestParam(defaultValue = "10") Integer pageSize) {
        try {
            // 验证参数
            if (furnaceNo == null && StringUtils.isEmpty(startDate) && StringUtils.isEmpty(endDate)) {
                return new TableDataInfo();
            }
            
            // 设置分页参数
            startPage();
            
            // 根据条件查询数据
            List<YdMeterData> dataList;
            if (furnaceNo != null) {
                dataList = ydMeterDataService.selectDataByFurnaceNo(furnaceNo, startDate, endDate);
            } else {
                // 当没有炉号参数时，查询所有数据
                dataList = ydMeterDataService.selectDataByTimeRange(startDate, endDate);
            }
            
            // 返回分页数据
            return getDataTable(dataList);
        } catch (Exception e) {
            log.error("分页查询数据异常，炉号：{}", furnaceNo, e);
            TableDataInfo rspData = new TableDataInfo();
            rspData.setCode(500);
            rspData.setMsg("查询失败：" + e.getMessage());
            return rspData;
        }
    }
    
    /**
     * 根据炉号和时间范围统计总功率和总用电量
     * @param furnaceNo 炉号（必填）
     * @param type 统计类型：day、month、year（必填）
     * @param date 日期，格式根据 type 变化（必填）
     * @return 结果
     */
    /**
     * 查询指定炉号在指定日期范围（日、月、年）内的总功率和总电量
     * @param furnaceNo 炉号
     * @param type 类型 day/month/year
     * @param date 日期字符串
     * @return 统计结果
     */
    @GetMapping("/totalByFurnace")
    public AjaxResult totalByFurnace(@RequestParam Integer furnaceNo,
                                     @RequestParam String type,
                                     @RequestParam String date) {
        Map<String, Object> result = ydMeterDataService.getTotalByFurnace(furnaceNo, type, date);
        Double sumElectricity = 0.0;
        if (result != null && result.get("sumElectricity") != null) {
            sumElectricity = Double.parseDouble(result.get("sumElectricity").toString());
        }
        Map<String, Object> response = new HashMap<>();
        response.put("sumElectricity", sumElectricity);
        return AjaxResult.success(response);
    }
}